home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 12 / Mac Magazin and MacEasy Magazine CD - Issue 12.iso / Sharewarebibliothek / Anwendungen / Wissenschaft & Technik / Yorick / yorick11-ppc folder / startup / zbuf.i < prev   
Text File  |  1995-06-29  |  24KB  |  863 lines
  1. /*
  2.    ZBUF.I
  3.    Yorick interface to z-buffered graphics. Uses same interface
  4.    as Munro's plwf, but scales coords to fit into the z-buffer
  5.    range.
  6.  
  7.    $Id: zbuf.i,v 1.1 1994/11/10 23:13:12 langer Exp $
  8.  */
  9. /*    Copyright (c) 1994.  The Regents of the University of California.
  10.                     All rights reserved.  */
  11.  
  12. /*
  13. require, "plwf.i";
  14. */
  15.  
  16. extern zbuf_terp;
  17. extern nx_zbuf_terp, ny_zbuf_terp;
  18. extern pixbuf_terp;
  19. extern z_viewplane, z_viewpoint;
  20. extern trans_vec1, trans_vec2, trans_vec3;
  21.  
  22. #if 0
  23. func _plzbf_mesh(y, x)
  24. {
  25.   extern _plwf_y_d, _plwf_x_d, _plwf_z_d;
  26.   extern _plwf_y, _plwf_x, _plwf_z;
  27.  
  28.   if (is_void(y)) {
  29.     _plwf_y= _plwf_y_d;
  30.     _plwf_x= _plwf_x_d;
  31.     _plwf_z= _plwf_z_d;
  32.     return;
  33.   }
  34.  
  35.   /* rotate (x,y,0) into on-screen orientation */
  36.   xs2=      x*cos(_plwf_psi)-y*sin(_plwf_psi);
  37.   _plwf_y=  y*cos(_plwf_psi)+x*sin(_plwf_psi);
  38.   _plwf_z= -xs2*sin(_plwf_theta);
  39.   xs2*=         cos(_plwf_theta);
  40.   _plwf_x= xs2*cos(_plwf_phi)-_plwf_y*sin(_plwf_phi);
  41.   _plwf_y= _plwf_y*cos(_plwf_phi)+xs2*sin(_plwf_phi);
  42.  
  43.   /* put center of mesh at (0,0) in screen coordinates */
  44.   _plwf_x -= avg(_plwf_x);
  45.   _plwf_y -= avg(_plwf_y);
  46.   _plwf_z -= avg(_plwf_z);
  47.  
  48.   /* normalize mesh so that biggest dimension is 1.0 */
  49.   /* WARNING WARNING - Original Munro version of _plwf_mesh 
  50.      does not work if there is a negative
  51.      element with a larger absolute value than the largest
  52.      positive element. Fix to use max(abs()).
  53.   */
  54.   xmax= max(abs(_plwf_x));
  55.   ymax= max(abs(_plwf_y));
  56.   if (ymax>xmax) xmax= ymax;
  57.   _plwf_x /= xmax;
  58.   _plwf_y /= xmax;
  59.   _plwf_z /= xmax;
  60. }
  61.  
  62. func plzbuf(fill,z,y,x, cull=,scale=)
  63. /* DOCUMENT plzbuf, z
  64.          or plzbuf, z, y,x
  65.      plots a 3-D z-buffered surface of the given Z array, which must have the
  66.      same dimensions as the mesh (X, Y).  The orientation of the
  67.      model can be set using the plwfset routine.  For most photogenic
  68.      results, use style="nobox.gs" in the window command, since the
  69.      projected axis ticks and labels are not very useful.
  70.      The viewpoint and default mesh can be set using the plwfset command.
  71.            fill  -- Colors to use for each zone, same dimension options as
  72.                     for z argument to plf function. If fill has 
  73.                     same dimension as z, will interpolate colors
  74.                     between corners. If fill is one smaller in each
  75.                     direction, each zone will be flat shaded.
  76. KEYWORDS: cull   -- default is 1 (cull back surfaces), but if you want
  77.                     to see the "underside" of the model, set to 0
  78.           scale  -- by default, Z is scaled to "reasonable" maximum
  79.                     and minimum values related to the scale of (X,Y).
  80.                     This keyword alters the default scaling factor, in
  81.                     the sense that scale=2.0 will produce twice  the
  82.                     Z-relief of the default scale=1.0.
  83.    SEE ALSO: plm, plf, plwfset, plwf
  84.  */
  85. {
  86.   extern nx_zbuf_terp, ny_zbuf_terp, pixbuf_terp;
  87.   extern _plwf_y, _plwf_x, _plwf_z;
  88.   extern _plwf_theta, _plwf_phi, _plwf_psi, _plwf_vf;
  89.  
  90.   _plzbf_mesh, y, x;
  91.  
  92.   zs= z;
  93.  
  94.   zs -= avg(zs);          /* center z at 0 */
  95.   zmax= max(zs);
  96.   sint= sin(_plwf_theta);
  97.   if (zmax && sint) {
  98.     zs /= zmax*sqrt(3)*sint;   /* guess at reasonable scale */
  99.     if (!is_void(scale)) zs *= scale;
  100.   }
  101.   xs= _plwf_x + zs*sint*cos(_plwf_phi);
  102.   ys= _plwf_y + zs*sint*sin(_plwf_phi);
  103.   zs= _plwf_z + zs*cos(_plwf_theta);
  104.  
  105.   /* (xs,ys) guaranteed to be centered at (0,0) by construction --
  106.      compute viewing distance and do perspective projection */
  107.   /* This is not really the advertised definition of viewfield,
  108.      but the real thing is very difficult to compute... */
  109.   z0= max(zs) + max(max(xs),max(ys))/_plwf_vf;
  110.   z0 -= zs;   /* guaranteed positive */
  111.   xs /= z0;
  112.   ys /= z0;
  113.  
  114.   /* scale to fit into plsys,0 (NDC coordinates) */
  115.   extern _plwf_xmin, _plwf_xmax, _plwf_ymin, _plwf_ymax;
  116.   xmax= max(xs);
  117.   xmin= min(xs);
  118.   ymax= max(ys);
  119.   ymin= min(ys);
  120.   s= (_plwf_xmax-_plwf_xmin)/(xmax-xmin);
  121.   sy= (_plwf_ymax-_plwf_ymin)/(ymax-ymin);
  122.   if (s<sy) {
  123.     ox= _plwf_xmin-s*xmin;
  124.     oy= 0.5*((_plwf_ymax+_plwf_ymin)-s*(ymin+ymax));
  125.   } else {
  126.     s= sy;
  127.     oy= _plwf_ymin-s*ymin;
  128.     ox= 0.5*((_plwf_xmax+_plwf_xmin)-s*(xmin+xmax));
  129.   }
  130.   xs= s*xs+ox;
  131.   ys= s*ys+oy;
  132.   /* scale x and y into range */
  133.   xslo= min(xs);
  134.   xshi= max(xs);
  135.   yslo= min(ys);
  136.   yshi= max(ys);
  137.   ix= long(nx_zbuf_terp*(xs-xslo)/(xshi-xslo)+0.9999);
  138.   iy= long(ny_zbuf_terp*(ys-yslo)/(yshi-yslo)+0.9999);
  139.   
  140.  
  141.   nx= numberof(ix(,1));
  142.   ny= numberof(ix(1,));
  143.   for(j= 1; j < ny; j++) {
  144.     for(i= 1; i < nx; i++) {
  145.       ixv= [ix(i,j), ix(i+1,j), ix(i,j+1)];
  146.       iyv= [iy(i,j), iy(i+1,j), iy(i,j+1)];
  147.       zv= [zs(i,j), zs(i+1,j), zs(i,j+1)];
  148.       icolr= char(fill(i,j));
  149.       tri_draw_1c, ixv, iyv, zv, icolr;
  150.       ixv= [ix(i+1,j), ix(i,j+1), ix(i+1,j+1)];
  151.       iyv= [iy(i+1,j), iy(i,j+1), iy(i+1,j+1)];
  152.       zv= [zs(i+1,j), zs(i,j+1), zs(i+1,j+1)];
  153.       tri_draw_1c, ixv, iyv, zv, icolr;
  154.     }
  155.   }
  156.   /* display the z-buffered image */
  157.   pli,pixbuf_terp;
  158. }
  159. #endif
  160.  
  161. /* ------------------------------------------------------------------------ */
  162.  
  163. func draw_tri(x, y, z, colr)
  164. /* DOCUMENT draw_tri(x, y, z, colr)
  165.      draws the triangle with corners at (x,y,z) where the three
  166.      variables are all vectors of length 3. colr may be either a scalar
  167.      color index for the whole triangle or a length 3 vector for the
  168.      three corners. Draws into the z-buffer which is later strobed
  169.      to the screen. The points are transformed using the current
  170.      projection.
  171.  
  172.    SEE ALSO: show_zbuf, set_proj;
  173.  */
  174. {
  175.   if(numberof(x) != 3 || numberof(y) != 3 || numberof(z) != 3) {
  176.     error,"coordinate array is not length three in draw_tri";
  177.   }
  178.   if(numberof(colr) != 1 && numberof(colr) != 3) {
  179.     error,"color must be of length 1 or 3 in draw_tri";
  180.   }
  181.   /* transform from world coords to viewpoint coords */
  182.   do_trans, x, y, z;
  183.   /* project the x and y coords */
  184.   project, x, y, z;
  185.   set_map_to_scrn, x, y;
  186.   map_to_scrn, x, y;
  187. #if 0
  188. x;y;
  189. colr;
  190. #endif
  191.   /* don't take a chance on the type of colr */
  192.   colr= char(colr);
  193.   if(numberof(colr) == 1) {
  194.     tri_draw_1c, x, y, z, colr;
  195.   } else {
  196.     tri_draw, x, y, z, colr;
  197.   }
  198.   show_zbuf;
  199. }
  200.  
  201. func draw_quad_strip(x, y, z, colr)
  202. /* DOCUMENT draw_quad_strip(x, y, z, colr)
  203.      draws the strip of quads with corners at (x,y,z). 
  204.      Dimensions for x,y,z are n by 2.
  205.      One quad (two triangles) is drawn for each group of four points, so
  206.      there are n-1 quads (2*(n-1) triangles). colr is a list
  207.      of color indices and may be either length n-1 to specify an
  208.      index for each quad or length n by 2 to specify an
  209.      index for each vertex, in which case the color of each point
  210.      is interpolated from the surrounding 3 vertices.
  211.      Draws into the z-buffer which is later strobed
  212.      to the screen. The points are transformed using the current
  213.      projection.
  214.  
  215.    SEE ALSO: show_zbuf, set_proj, draw_tri, draw_tri_list, draw_tri_strip;
  216.  */
  217. {
  218.   dimsx= dimsof(x);
  219.   dimsy= dimsof(y);
  220.   dimsz= dimsof(z);
  221.   dimsc= dimsof(colr);
  222.   if(anyof(dimsx != dimsy) || anyof(dimsx != dimsz)) {
  223.     error,"x,y,z arrays do not have same shape in draw_quad_strip";
  224.   }
  225.   if(dimsx(1) != 2) {
  226.     error,"coordinate arrays must be two dimensional in draw_quad_strip";
  227.   }
  228.   if(dimsx(3) != 2) {
  229.     error,"coordinate arrays must be n by 2 in draw_quad_strip";
  230.   }
  231.   num= dimsx(2);
  232.   if(dimsc(1) == 1) {
  233.     if(dimsc(2) != num-1) {
  234.       error,"color array must be n-1 vector or n by 2 in draw_quad_strip";
  235.     }
  236.     /* one color per triangle */
  237.     one_colr= 1;
  238.   } else if(anyof(dimsx != dimsc)) {
  239.     error,"color array must be n-1 vector or n by 2 in draw_quad_strip";
  240.   } else {
  241.     /* one color index per vertex */
  242.     one_colr= 0;
  243.   }
  244.   /* transform from world coords to viewpoint coords */
  245.   do_trans, x, y, z;
  246.   /* project the x and y coords */
  247.   project, x, y, z;
  248.   set_map_to_scrn, x, y;
  249.   map_to_scrn, x, y;
  250.   /* don't take a chance on the type of colr */
  251.   colr= char(colr);
  252.   if(one_colr) {
  253.     quad_strip_1c, numberof(x(,1)), x(,1), x(,2), y(,1), y(,2), z(,1), z(,2), colr;
  254.   } else {
  255.     quad_strip, numberof(x(,1)), x(,1), x(,2), y(,1), y(,2), z(,1), z(,2), colr(,1), colr(,2);
  256.   }
  257.   show_zbuf;
  258. }
  259.  
  260. func draw_tri_strip(x, y, z, colr)
  261. /* DOCUMENT draw_tri_strip(x, y, z, colr)
  262.      draws the strip of triangles with corners at (x,y,z). 
  263.      One triangle is drawn for each group of three points, so
  264.      there are n-2 triangles if there are n points. colr is a list
  265.      of color indices and may be either length n-2 to specify an
  266.      index for each triangle or length n to specify an
  267.      index for each vertex, in which case the color of each point
  268.      in a triangle is interpolated from the vertices.
  269.      Draws into the z-buffer which is later strobed
  270.      to the screen. The points are transformed using the current
  271.      projection.
  272.  
  273.    SEE ALSO: show_zbuf, set_proj, draw_tri, draw_tri_list;
  274.  */
  275. {
  276.   dimsx= dimsof(x);
  277.   dimsy= dimsof(y);
  278.   dimsz= dimsof(z);
  279.   dimsc= dimsof(colr);
  280.   if(anyof(dimsx != dimsy) || anyof(dimsx != dimsz)) {
  281.     error,"x,y,z arrays do not have same shape in draw_tri_strip";
  282.   }
  283.   if(dimsx(1) != 1) {
  284.     error,"coordinate arrays must be one dimensional in draw_tri_strip";
  285.   }
  286.   if(dimsc(1) != 1) {
  287.     error,"color array must be one dimensional in draw_tri_strip";
  288.   }
  289.   if(dimsc(2) == dimsx(2)) {
  290.     /* one color index per vertex */
  291.     one_colr= 0;
  292.   } else if(dimsc(2) == dimsx(2)-2) {
  293.     /* one color index per triangle */
  294.     one_colr= 1;
  295.   } else {
  296.     error,"number of colors must equal number of vertices or two less for draw_tri_strip";
  297.   }
  298.   /* transform from world coords to viewpoint coords */
  299.   do_trans, x, y, z;
  300. #if 0
  301. write,"after do_trans";
  302. "x=";x;
  303. "y=";y;
  304. "z=";z;
  305. #endif
  306.   /* project the x and y coords */
  307.   project, x, y, z;
  308. #if 0
  309. write,"after project";
  310. "x=";x;
  311. "y=";y;
  312. "z=";z;
  313. #endif
  314.   set_map_to_scrn, x, y;
  315.   map_to_scrn, x, y;
  316. #if 0
  317. write,"after map_to_scrn";
  318. "x=";x;
  319. "y=";y;
  320. #endif
  321.   num= dimsx(2);
  322.   /* don't take a chance on the type of colr */
  323.   colr= char(colr);
  324.   if(one_colr) {
  325.     tri_strip_1c, num, x, y, z, colr;
  326.   } else {
  327.     tri_strip, num, x, y, z, colr;
  328.   }
  329.   show_zbuf;
  330. }
  331.  
  332. func draw_tri_list(x, y, z, colr)
  333. /* DOCUMENT draw_tri_list(x, y, z, colr)
  334.      x,y,z have dimensions 3 by n. This function draws the 
  335.      triangles with corners at (x(,j),y(,j),z(,j)). 
  336.      colr is a list of color indices and may be either n to specify an
  337.      index for each triangle or size 3 by n to specify an
  338.      index for each vertex, in which case the color of each point
  339.      in a triangle is interpolated from the vertices.
  340.      Draws into the z-buffer which is later strobed
  341.      to the screen. The points are transformed using the current
  342.      projection.
  343.  
  344.    SEE ALSO: show_zbuf, set_proj, draw_tri, draw_tri_strip;
  345.  */
  346. {
  347.   dimsx= dimsof(x);
  348.   dimsy= dimsof(y);
  349.   dimsz= dimsof(z);
  350.   dimsc= dimsof(colr);
  351.   if(anyof(dimsx != dimsy) || anyof(dimsx != dimsz)) {
  352.     error,"x,y,z arrays do not have same shape in draw_tri_list";
  353.   }
  354.   if(dimsx(1) != 2) {
  355.     error,"coordinate arrays must be two dimensional in draw_tri_list";
  356.   }
  357.   if(dimsx(2) != 3) {
  358.     error,"coordinate arrays must have length 3 for first index in draw_tri_list";
  359.   }
  360.   if(dimsc(1) == 1) {
  361.     /* should be one index per triangle */
  362.     if(dimsc(2) != dimsx(3)) {
  363.       error,"color array must be one per triangle or one per vertex in draw_tri_list";
  364.     }
  365.     one_colr= 1;
  366.   } else if(dimsc(2) != 2) {
  367.     error,"color array must be one or two dimensional in draw_tri_list";
  368.   } else if(dimsc(3) != dimsx(3)) {
  369.     error,"color array must be one per triangle or one per vertex in draw_tri_list";
  370.   } else {
  371.     one_colr= 0;
  372.   }
  373.   /* transform from world coords to viewpoint coords */
  374.   do_trans, x, y, z;
  375.   /* project the x and y coords */
  376.   project, x, y, z;
  377.   set_map_to_scrn, x, y;
  378.   map_to_scrn, x, y;
  379. #if 0
  380. x;y;z;
  381. colr;
  382. #endif
  383.   num= dimsx(3);
  384.   /* don't take a chance on the type of colr */
  385.   colr= char(colr);
  386.   if(one_colr) {
  387.     for(i= 1; i <= num; i++) {
  388.       tri_draw_1c, x(,i), y(,i), z(,i), colr(i);
  389.     }
  390.   } else {
  391.     for(i= 1; i <= num; i++) {
  392.       tri_draw, x(,i), y(,i), z(,i), colr(,i);
  393.     }
  394.   }
  395.   show_zbuf;
  396. }
  397.  
  398.  
  399. struct link3d {
  400.   long is_quad, one_colr;
  401.   char *colr;
  402.   double *data_x, *data_y, *data_z;
  403.   double *rot_x, *rot_y, *rot_z;
  404.   double *adj_z;
  405.   double *proj_x, *proj_y;
  406.   double *map_x, *map_y;
  407.   link3d *next;
  408.   link3d *prev;
  409. }
  410.  
  411. func clr_zbuf
  412. {
  413.   extern zbuf_terp;
  414.   extern pixbuf_terp;
  415.  
  416.   zbuf_terp(..)= -1.0e100;
  417.   pixbuf_terp(..)= char(0);
  418. }
  419.  
  420. func add_link3d(x, y, z, colr)
  421. /* DOCUMENT add_link3d(x, y, z, colr)
  422.    1) draws the strip of triangles with corners at (x,y,z)
  423.       if x, y, and z are 1D arrays. 
  424.       One triangle is drawn for each group of three points, so
  425.       there are n-2 triangles if there are n points. colr is a list
  426.       of color indices.
  427.       If colr has the same length as x, y, z, there is a color
  428.       for each vertex and the colors are interpolated linearly
  429.       between vertices. If colr has length 2 less than x, y, and z, 
  430.       there is a single color for each triangle.
  431.    2) draws the strip of quads with corners at (x,y,z)  
  432.       if the dimensions for x,y,z are n by 2.
  433.       One quad (two triangles) is drawn for each group of four points,
  434.       so there are n-1 quads (2*(n-1) triangles). colr is a list
  435.       of color indices and may be either length n-1 to specify an
  436.       index for each quad or length n by 2 to specify an
  437.       index for each vertex, in which case the color of each point
  438.       is interpolated from the surrounding 3 vertices.
  439.  
  440.    SEE ALSO: show_zbuf, set_proj, draw_tri, draw_tri_list;
  441.  */
  442. {
  443.   dimsx= dimsof(x);
  444.   dimsy= dimsof(y);
  445.   dimsz= dimsof(z);
  446.   dimsc= dimsof(colr);
  447.   if(anyof(dimsx != dimsy) || anyof(dimsx != dimsz)) {
  448.     error,"x,y,z arrays do not have same shape in add_link3d";
  449.   }
  450.   if(dimsx(1) < 1 || dimsx(1) > 2) {
  451.     error,"coordinate arrays must be one or two two dimensional in add_link3d";
  452.   }
  453.   if(dimsx(1) == 1) {
  454.     /* triangle strip */
  455.     is_quad= 0;
  456.     if(dimsc(1) != 1) {
  457.       error,"color array must be one dimensional for triangle strip in add_link3d";
  458.     }
  459.     if(dimsc(2) == dimsx(2)) {
  460.       /* one color index per vertex */
  461.       one_colr= 0;
  462.     } else if(dimsc(2) == dimsx(2)-2) {
  463.       /* one color index per triangle */
  464.       one_colr= 1;
  465.     } else {
  466.       error,"number of colors must equal number of vertices or two less for add_link3d";
  467.     }
  468.   } else {
  469.     /* quad strip */
  470.     is_quad= 1;
  471.     if(dimsx(3) != 2) {
  472.       error,"coordinate arrays must be n by 2 for quad strip in add_link3d";
  473.     }
  474.     num= dimsx(2);
  475.     if(dimsc(1) == 1) {
  476.       if(dimsc(2) != num-1) {
  477.         error,"color array must be n-1 vector or n by 2 for quad strip in add_link3d";
  478.       }
  479.       /* one color per triangle */
  480.       one_colr= 1;
  481.     } else if(anyof(dimsx != dimsc)) {
  482.       error,"color array must be n-1 vector or n by 2 for quad strip in add_link3d";
  483.     } else {
  484.       /* one color index per vertex */
  485.       one_colr= 0;
  486.     }
  487.   }
  488.  
  489.   link= array(link3d);
  490.   link.next= list3d_head.next;
  491.   if(link.next) (link.next)->prev= &link;
  492.   link.prev= &list3d_head;
  493.   list3d_head.next= &link;
  494.  
  495.   link.data_x= &x;
  496.   link.data_y= &y;
  497.   link.data_z= &z;
  498.   link.colr= &colr;
  499.   link.one_colr= one_colr;
  500.   link.is_quad= is_quad;
  501.  
  502.   link.rot_x= link.rot_y= link.rot_z= pointer(0);
  503.   link.proj_x= link.proj_y= pointer(0);
  504.   link.adj_z= pointer(0);
  505.  
  506.   return &link;
  507. }
  508.  
  509. func show_list3d
  510. {
  511.   link= list3d_head.next;
  512.   while(link) {
  513.     if(link->is_quad) {
  514.       xx= *(link->map_x);
  515.       yy= *(link->map_y);
  516.       zz= *(link->adj_z);
  517.       colr= *(link->colr);
  518.       num= numberof( xx(,1) );
  519.       if(link->one_colr) {
  520.         quad_strip_1c, num, xx(,1), xx(,2),  yy(,1), yy(,2), 
  521.                       zz(,1), zz(,2), colr;
  522.       } else {
  523.         quad_strip_1c, num, xx(,1), xx(,2),  yy(,1), yy(,2), 
  524.                       zz(,1), zz(,2), colr(,1), colr(,2);
  525.       }
  526.     } else {
  527.       num= numberof( *(link->map_x) );
  528.       if(link->one_colr) {
  529.         tri_strip_1c, num, *(link->map_x), *(link->map_y), 
  530.                       *(link->adj_z), *(link->colr);
  531.       } else {
  532.         tri_strip, num, *(link->map_x), *(link->map_y), 
  533.                    *(link->adj_z), *(link->colr);
  534.       }
  535.     }
  536.     link= link->next;
  537.   }
  538.   show_zbuf;
  539. }
  540.  
  541. func remov_link3d(link)
  542. {
  543.   if(typeof(link) != "struct_instance") {
  544.     error,"remov_link called with a bad argument, must be a link3d struct";
  545.   }
  546. #if 0
  547.   if(structof(link) != "link3d") {
  548.     error,"remov_link called with a bad argument, must be a link3d struct";
  549.   }
  550. #endif
  551.   if(link.next) (link.next)->prev= link.prev;
  552.   if(link.prev) (link.prev)->next= link.next;
  553. }
  554.  
  555. func clear_list3d(dlist)
  556. {
  557.   while(list3d_head.next) {
  558.     remov_link3d(*(list3d_head.next));
  559.   }
  560. }
  561.  
  562. func rot_list3d
  563. {
  564.   link= list3d_head.next;
  565.   while(link) {
  566.     xx= *(link->data_x);
  567.     yy= *(link->data_y);
  568.     zz= *(link->data_z);
  569.     do_rotn, xx, yy, zz;
  570.     link->rot_x= &xx;
  571.     link->rot_y= &yy;
  572.     link->rot_z= &zz;
  573.     link= link->next;
  574.   }
  575. }
  576.  
  577. func pick_zview
  578. {
  579.   lims= lims_list3d(list3d_head);
  580.   /* Back up a reasonable distance from the set of objects.
  581.      This calculation is done in viewpoint coords, so zview
  582.      must be greater than zmax for the default view.
  583.      Base the distance on the range of x and y values.
  584.   */
  585.   zview= lims(3,2)+3.0*max(lims(1,2)-lims(1,1), lims(2,2)-lims(2,1));
  586.   set_zview,zview;
  587. }
  588.  
  589. func lims_list3d(head)
  590. {
  591.   link= head.next;
  592.   xlo= ylo= zlo= 1.0e200;
  593.   xhi= yhi= zhi= -1.0e200;
  594.   while(link) {
  595.     xlo= min(xlo, min( *(link->rot_x) ) );
  596.     xhi= max(xhi, max( *(link->rot_x) ) );
  597.     ylo= min(ylo, min( *(link->rot_y) ) );
  598.     yhi= max(yhi, max( *(link->rot_y) ) );
  599.     zlo= min(zlo, min( *(link->rot_z) ) );
  600.     zhi= max(zhi, max( *(link->rot_z) ) );
  601.     link= link->next;
  602.   }
  603.   res= array(0.0, 3, 2);
  604.   res(1,1)= xlo;
  605.   res(2,1)= ylo;
  606.   res(3,1)= zlo;
  607.   res(1,2)= xhi;
  608.   res(2,2)= yhi;
  609.   res(3,2)= zhi;
  610.   return res;
  611. }
  612.  
  613. func adj_z_list3d
  614. {
  615.   link= list3d_head.next;
  616.   while(link) {
  617.     zz= *(link->rot_z);
  618.     adj_zvals, zz;
  619.     link->adj_z= &zz;
  620.     link= link->next;
  621.   }
  622. }
  623.  
  624. func proj_list3d
  625. {
  626.   link= list3d_head.next;
  627.   while(link) {
  628.     xx= *(link->rot_x);
  629.     yy= *(link->rot_y);
  630.     project, xx, yy, *(link->adj_z);
  631.     link->proj_x= &xx;
  632.     link->proj_y= &yy;
  633.     link= link->next;
  634.   }
  635. }
  636.  
  637. func set_map_from_list3d
  638. {
  639.   extern zbuf_x_off, zbuf_y_off, zbuf_x_scale, zbuf_y_scale;
  640.  
  641.   /* compute the transformation between projected 3D viewpoint coords
  642.      and z-buffer coords */
  643.   link= list3d_head.next;
  644.   xlo= ylo= 1.0e200;
  645.   xhi= yhi= -1.0e200;
  646.   while(link) {
  647.     xx= *(link->proj_x);
  648.     yy= *(link->proj_y);
  649.     xlo= min(xlo, min(xx));
  650.     xhi= max(xhi, max(xx));
  651.     ylo= min(ylo, min(yy));
  652.     yhi= max(yhi, max(yy));
  653.     link= link->next;
  654.   }
  655.   zbuf_x_off= xlo;
  656.   zbuf_y_off= ylo;
  657.   zbuf_x_scale= nx_zbuf_terp/(xhi-zbuf_x_off);
  658.   zbuf_y_scale= nx_zbuf_terp/(yhi-zbuf_y_off);
  659. }
  660.  
  661. func map_list3d
  662. {
  663.   link= list3d_head.next;
  664.   while(link) {
  665.     xx= *(link->proj_x);
  666.     yy= *(link->proj_y);
  667.     map_to_scrn, xx, yy;
  668.     link->map_x= &xx;
  669.     link->map_y= &yy;
  670.     link= link->next;
  671.   }
  672. }
  673.  
  674. func init_zbuf(nx, ny)
  675. {
  676.   extern zbuf_terp;
  677.   extern nx_zbuf_terp;
  678.   extern ny_zbuf_terp;
  679.   extern pixbuf_terp;
  680.   extern list3d_head;
  681.  
  682.   if(nx < 4 || ny < 4 || nx > 4096 || ny > 4096) {
  683.     error,"init_zbuf(), nx or ny is out of range";
  684.   }
  685.   if(is_void(list3d_head)) {
  686.     list3d_head= array(link3d);
  687.     list3d_head.data_x= list3d_head.data_y= list3d_head.data_z= pointer(0);
  688.     list3d_head.rot_x= list3d_head.rot_y= list3d_head.rot_z= pointer(0);
  689.     list3d_head.proj_x= list3d_head.proj_y= pointer(0);
  690.     list3d_head.adj_z= pointer(0);
  691.     list3d_head.one_colr= 0;
  692.     list3d_head.is_quad= 0;
  693.   }
  694.   /* make new z-buffer only if sizes have changed */
  695.   if(nx != nx_zbuf_terp || ny != ny_zbuf_terp) {
  696.     nx_zbuf_terp= nx;
  697.     ny_zbuf_terp= ny;
  698.     zbuf_terp= array(0.0, nx, ny);
  699.     pixbuf_terp= array(char(0), nx, ny);
  700.     clr_zbuf;
  701.     _init_zbuf,nx, ny, zbuf_terp, pixbuf_terp;
  702.   }
  703. }
  704.  
  705. func show_zbuf
  706. {
  707.   extern pixbuf_terp;
  708.  
  709.   pli,pixbuf_terp;
  710. }
  711.  
  712. func project(&x, &y, z)
  713. {
  714.   extern z_viewplane;
  715.  
  716.   /* perform perspective projection of the vectors x, y, z */
  717.   if(numberof(x) != numberof(y) || numberof(x) != numberof(z)) {
  718.     error,"vectors of different length passed to project()";
  719.   }
  720.   x *= z_viewplane/z;
  721.   y *= z_viewplane/z;
  722. }
  723.  
  724. func set_zviewpoint(view_loc)
  725. {
  726.   extern z_viewpoint;
  727.   
  728.   /* Transform the viewpoint from world coords to viewpoint coords.
  729.      Anything with a z greater than the resulting z cannot be seen */
  730.   xp= trans_vec1(1)*view_loc(1)+trans_vec1(2)*view_loc(2)+trans_vec1(3)*view_loc(3);
  731.   yp= trans_vec2(1)*view_loc(1)+trans_vec2(2)*view_loc(2)+trans_vec2(3)*view_loc(3);
  732.   zp= trans_vec3(1)*view_loc(1)+trans_vec3(2)*view_loc(2)+trans_vec3(3)*view_loc(3);
  733.   z_viewpoint= zp;
  734. }
  735.  
  736. func do_trans(&x, &y, &z)
  737. {
  738.   do_rotn,x,y,z;
  739.   adj_zvals,z;
  740. }
  741.  
  742. func adj_zvals(&z)
  743. {
  744.   extern z_viewpoint;
  745.  
  746.   /* adjust so viewer is at z=0 */
  747.   z -= z_viewpoint;
  748.   if(max(z) >= 0.0) "Warning: at least one point is behind viewpoint";
  749. }
  750.  
  751. func do_rotn(&x, &y, &z)
  752. {
  753.   extern trans_vec1;
  754.   extern trans_vec2;
  755.   extern trans_vec3;
  756.  
  757.   if(numberof(x) != numberof(y) || numberof(x) != numberof(z)) {
  758.     error,"vectors of different length passed to do_rotn()";
  759.   }
  760.   xp= trans_vec1(1)*x+trans_vec1(2)*y+trans_vec1(3)*z;
  761.   yp= trans_vec2(1)*x+trans_vec2(2)*y+trans_vec2(3)*z;
  762.   zp= trans_vec3(1)*x+trans_vec3(2)*y+trans_vec3(3)*z;
  763. #if 0
  764. write,"min(z) after rotation=",min(zp);
  765. write,"max(z) after rotation=",max(zp);
  766. #endif
  767.   x= xp;
  768.   y= yp;
  769. }
  770.  
  771. func set_trans(zview, theta, phi, psi)
  772. {
  773.   extern view_world;
  774.  
  775.   set_rotn,theta, phi, psi;
  776.   set_zviewplane, zview;
  777.   set_zviewpoint, view_world;
  778. }
  779.  
  780. func set_zview(zview)
  781. {
  782.   extern z_viewpoint;
  783.  
  784.   z_viewpoint= zview;
  785. }
  786.  
  787. func set_zviewplane(zval)
  788. {
  789.   extern z_viewplane;
  790.  
  791.   z_viewplane= zval;
  792. }
  793.  
  794. func set_rotn(theta, phi, psi)
  795. {
  796.   extern trans_vec1;
  797.   extern trans_vec2;
  798.   extern trans_vec3;
  799.  
  800.   /* compute the transformation between world coords and 
  801.      the 3D viewpoint coords */
  802.   snth= sin(theta);
  803.   csth= cos(theta);
  804.   snph= sin(phi);
  805.   csph= cos(phi);
  806.   snpsi= sin(psi);
  807.   cspsi= cos(psi);
  808.   trans_vec1= [-csth*csph*snpsi-snph*cspsi, -csth*snph*snpsi+csph*cspsi,
  809.                snth*snpsi];
  810.   trans_vec2= [-csth*csph*cspsi+snph*snpsi, -csth*snph*cspsi-csph*snpsi,
  811.                snth*cspsi];
  812.   trans_vec3= [snth*csph, snth*snph, csth];
  813. }
  814.  
  815. func map_to_scrn(&x, &y)
  816. {
  817.   extern zbuf_x_off, zbuf_y_off, zbuf_x_scale, zbuf_y_scale;
  818.  
  819.   x= (x-zbuf_x_off)*zbuf_x_scale+1.0;
  820.   y= (y-zbuf_y_off)*zbuf_y_scale+1.0;
  821.   /* shouldn't be necessary, but do anyhow */
  822. #if 0
  823.   x= max(1, min(nx_zbuf_terp, x));
  824.   y= max(1, min(ny_zbuf_terp, y));
  825. #endif
  826. }
  827.  
  828. #if 0
  829. func map_to_scrn(&x, &y)
  830. {
  831.   extern zbuf_x_off, zbuf_y_off, zbuf_x_scale, zbuf_y_scale;
  832.  
  833.   x= long( (x-zbuf_x_off)*zbuf_x_scale+1.5 );
  834.   y= long( (y-zbuf_y_off)*zbuf_y_scale+1.5 );
  835.   /* shouldn't be necessary, but do anyhow */
  836.   x= max(1, min(nx_zbuf_terp, x));
  837.   y= max(1, min(ny_zbuf_terp, y));
  838. }
  839. #endif
  840.  
  841. func set_map_to_scrn(xvals, yvals)
  842. {
  843.   extern zbuf_x_off, zbuf_y_off, zbuf_x_scale, zbuf_y_scale;
  844.  
  845.   /* compute the transformation between projected 3D viewpoint coords
  846.      and z-buffer coords */
  847.   xmx= max(xvals);
  848.   zbuf_x_off= min(xvals);
  849.   ymx= max(yvals);
  850.   zbuf_y_off= min(yvals);
  851.   zbuf_x_scale= nx_zbuf_terp/(xmx-zbuf_x_off);
  852.   zbuf_y_scale= nx_zbuf_terp/(ymx-zbuf_y_off);
  853. }
  854.  
  855. /* create an initial z-buffer and pixmap */
  856. if(numberof(zbuf_terp) < 16) {
  857.   nx_zbuf_terp= 0;
  858.   ny_zbuf_terp= 0;
  859. }
  860. init_zbuf, 64, 64;
  861. view_world= [0.0, 0.0, 100.0];
  862. set_trans, -1.0, pi/4.0, 0.0, pi/2.0;
  863.